/**
**************************************************************************************
*Palisma - Secrets of the Illuminati is an open-source 2D RPG                        *
*Copyright (C) 2006, Tony Sparks                                                     *
*                                                                                    *
*This library is free software; you can redistribute it and/or                       *
*modify it under the terms of the GNU Lesser General Public                          *
*License as published by the Free Software Foundation; either                        *
*version 2.1 of the License, or (at your option) any later version.                  *
*                                                                                    *
*This library is distributed in the hope that it will be useful,                     *
*but WITHOUT ANY WARRANTY; without even the implied warranty of                      *
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU                   *
*Lesser General Public License for more details.                                     *
*                                                                                    *
*You should have received a copy of the GNU Lesser General Public                    *
*License along with this library; if not, write to the Free Software                 *
*Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA      *
**************************************************************************************
*/
#pragma once
#include <math.h>

#pragma warning( disable : 4244)

inline float roundf( float n ) 
{
    return floor( fabs(n)+0.5f );
}

#define PIOVER180 0.017453293
#define EPSILON   0.01f
class Vector2f
{
public:
	inline Vector2f(void)									{  };
	inline Vector2f(float X, float Y)						{ x = X; y = Y; };
	inline Vector2f operator+(const Vector2f& v)	const	{ return Vector2f(x+v.x, y+v.y);	};
	inline Vector2f operator-(const Vector2f& v)	const	{ return Vector2f(x-v.x, y-v.y);	};
	inline Vector2f operator*(float fl)				const	{ return Vector2f(x*fl, y*fl);	    };
    inline Vector2f operator*(const Vector2f& v)	const	{ return Vector2f(x*v.x, y*v.y);	};
	inline Vector2f operator/(float fl)				const	{ return Vector2f(x/fl, y/fl);	    };
    inline bool operator!=(const Vector2f& v)       const   { return ((fabs(x - v.x) > EPSILON) || (fabs(y - v.y) > EPSILON)); };
    inline bool operator==(const Vector2f& v)		const	{ return !( *this != v);	};
    inline void operator=(const Vector2f& v)		    	{ x = v.x; y = v.y;	};

	
    inline void ZeroOut() 
    {
        x = 0; y = 0;
    };
	inline float Length(void) const							
	{ 
		return sqrtf(x*x + y*y);		
	};

	inline void Normalize ( void )
	{
		float flLen = Length();
        if ( !flLen ) return;
		flLen = 1.0f / flLen;
		x = x * flLen;
		y = y * flLen;
	};

    inline bool Equals( const Vector2f& v, float epsilon=0.01f )
    {
        return !((fabs(x - v.x) > epsilon) || (fabs(y - v.y) > epsilon)); 
    };

    inline void Round()
    {
        x = roundf( x );
        y = roundf( y );
    };

    inline void Snap()
    {
        x = (int)x;
        y = (int)y;
    };

    inline Vector2f SnapVector() const
    {
        return Vector2f( (int)x, (int)y );
    };

    inline void Invert()
    {
        x = -x;
        y = -y;
    };

	inline void Multiply(const Vector2f &v)
	{
		x = sqrtf(x*x + v.x*v.x);
		y = sqrtf(y*y + v.y*v.y);
	};

	inline float DotProduct(const Vector2f &v) const
	{
		return x * v.x + y * v.y;
	};

	inline float Angle(const Vector2f &v) const
	{
		float dp = DotProduct(v);
		float l1 = Length();
		float l2 = v.Length();
		return acos(dp / (l1 * l2));
	};

    inline float Distance(const Vector2f &v ) const 
    {
        return sqrtf( ( v.x - x )*( v.x - x ) + ( v.y - x )*( v.y - y ) );
    };

    inline void Set(float toX, float toY)
    {
        x = toX;
        y = toY;
    };

    inline void Set( const Vector2f& v )
    {
        x = v.x; y = v.y;
    };

	float	x, y;
};

